#include "MessageTxRx.h"

#include <Serializable.h>

MessageTxRx::MessageTxRx()
{
}

MessageTxRx::MessageTxRx(const MessageTxRx& other)
{
}

MessageTxRx::~MessageTxRx()
{
}

std::string MessageTxRx::obtenerAtributoDeReceptor(FifoLectura& receptor, 
												   const std::string& nombreAtributo, 
												   bool shouldLock)
{
	std::string atributo = "";
	
	// Leo la longitud del mensaje a recibir
	ssize_t buffer1Size = sizeof(int);
	char buffer1[buffer1Size];
	if(shouldLock)
		receptor.lock();
	try
	{
		receptor.leer(static_cast<void*>(buffer1), buffer1Size);
		ssize_t* packetSize = (ssize_t*) buffer1;
		if(*packetSize > 0)
		{
			char buffer2[*packetSize];
			receptor.leer(static_cast<void*>(buffer2), *packetSize);
			if(shouldLock)
				receptor.unlock();
			
			ObjectSerializable ob(buffer2, *packetSize);
			atributo = ob.GetAttribute(nombreAtributo);
		}
		else
		{
			throw BaseException("Se recibio un paquete sin contenido");
		}
	}
	catch(const BaseException& e)
	{
		if(shouldLock)
			receptor.unlock();
		throw e;
	}
	return atributo;
}

void MessageTxRx::enviarAtributoAReceptor(FifoEscritura& receptor, 
								   const std::string& nombreAtributo, 
								   const std::string& valorAtributo,
								   bool shouldLock)
{
	ObjectSerializable obSerializable;
	obSerializable.AddAttribute(nombreAtributo, valorAtributo);
	int tamPaquete = obSerializable.getSize();
	
	if(shouldLock)
		receptor.lock();
	try
	{
		receptor.escribir(static_cast<const void*> (&tamPaquete), sizeof(int));
		receptor.escribir(static_cast<const void*> (obSerializable.Serialize()), tamPaquete);
		if(shouldLock)
			receptor.unlock();
	}
	catch(const BaseException& e)
	{
		if(shouldLock)
			receptor.unlock();
		throw e;
	}
}
